package org.jeecg.modules.zhouAdmin.admin.orderCenterModule.controller;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.degression.pojo.MlccPaidanOrderGongyi;
import org.jeecg.modules.zhouAdmin.admin.orderCenterModule.pojo.*;
import org.jeecg.modules.zhouAdmin.admin.orderCenterModule.service.IOrderCenterService;
import org.jeecg.modules.zhoupackage.pojo.*;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

import java.util.List;

/**
 * 总后台订单中心
 */
@RestController
@RequestMapping("/orderCenter")
public class OrderCenterController {

    @Autowired
    IOrderCenterService service;

    /**
     * 获取面料订单
     *
     * @param pageNo    当前页
     * @param pageSize  页面大小
     * @param orderSn   订单编号
     * @param storeCode 门店编码
     * @param gysName   供应商名称
     * @param status    订单状态
     * @param date      开始时间
     */
    @RequestMapping("/getFabricOrder")
    public Result<?> getFabricOrder(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                    @RequestParam(name = "pageSize", defaultValue = "10") int pageSize,
                                    String orderSn, String storeCode,
                                    String gysName, String status, String[] date) {
        Page<AdminFabricOrder> page = new Page<>(pageNo, pageSize);
        String start = "";
        String end = "";
        if (date != null) {
            if (date[0] != null) {
                start = date[0];
            }
            if (date[1] != null) {
                end = date[1] + " 23:59:59";
            }
        }
        System.out.println("结束时间" + end);
        return Result.ok(service.getFabricOrder(page, orderSn, storeCode, gysName, status, start, end));
    }

    /**
     * 面料订单立即接单
     *
     * @param orderSn 订单编号
     */
    @RequestMapping("/orderNow")
    public Result<?> orderNow(String orderSn, String remark) {
        int result = service.orderNow(orderSn, remark);
        if (result > 0) {
            return Result.ok("接单成功");
        }
        return Result.error("接单失败");
    }

    /**
     * 个订订单立即接单
     *
     * @param orderSn 个订订单编号
     */
    @RequestMapping("/orderNowSingle")
    public JSONObject orderNowSingle(String orderSn) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.orderNowSingle(orderSn);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "接单成功");
            } else if (result == -1) {
                jsonObject.put("code", -1);
                jsonObject.put("msg", "产品还没有选择供应商");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "该订单不存在或已结单");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 面料订单确认收货
     *
     * @param orderSn 顶动感编号
     */
    @RequestMapping("/theGoods")
    public Result<?> theGoods(String orderSn) {
        int result = service.theGoods(orderSn);
        if (result > 0) {
            return Result.ok("接单成功");
        }
        return Result.error("接单失败");
    }

    /**
     * 获取个订订单
     *
     * @param pageNo    当前页
     * @param pageSize  页面大小
     * @param orderSn   订单编号
     * @param storeCode 门店编码
     * @param gysName   供应商名称
     * @param status    订单状态
     * @param date      时间
     */
    @RequestMapping("/getSingleOrder")
    public Result<?> getSingleOrder(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                    @RequestParam(name = "pageSize", defaultValue = "10") int pageSize,
                                    String orderSn, String storeCode,
                                    String gysName, String status, String date, String enddate) {
        Page<AdminSingleOrder> page = new Page<>(pageNo, pageSize);
        if (enddate != null && !"".equals(enddate)) {
            enddate = enddate + " 23:59:59";
        }
        return Result.ok(service.getSingleOrder(page, orderSn, storeCode, gysName, status, date, enddate));
    }

    /**
     * 获取团订订单列表
     *
     * @param pageNo    当前页
     * @param pageSize  页面大小
     * @param orderSn   订单编号
     * @param storeCode 门店名称
     * @param status    状态
     * @param date      下单时间
     * @return 分页数据
     */
    @RequestMapping("/getTeamOrder")
    public Result<?> getTeamOrder(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                  @RequestParam(name = "pageSize", defaultValue = "10") int pageSize,
                                  String orderSn, String storeCode, String status, String date, String enddate) {
        Page<AdminTeamOrder> page = new Page<>(pageNo, pageSize);
        if (enddate != null && !"".equals(enddate)) {
            enddate = enddate + " 23:59:59";
        }
        try {
            IPage<AdminTeamOrder> iPage = service.getTeamOrder(page, orderSn, storeCode, status, date, enddate);
            return Result.ok(iPage);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 总后台获取个订订单详情
     *
     * @param orderSn 订单编号
     */
    @RequestMapping("/SingleOrderDetail")
    public JSONObject SingleOrderDetail(String orderSn) {
        JSONObject jsonObject = new JSONObject();
        try {
            MlccSingleOrderInfo buttonSelect = service.getDingleOrderDetail(orderSn);
            jsonObject.put("code", 0);
            jsonObject.put("msg", "查询成功");
            jsonObject.put("data", buttonSelect);
            return jsonObject;
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
            return jsonObject;
        }
    }

    /**
     * 未支付订单的调价
     *
     * @param orderType 订单类型 3面料，0个订，1团订
     * @param orderSn   订单编号
     * @param price     设置的价格
     */
    @RequestMapping("/pricing")
    public Result<?> pricing(Integer orderType, String orderSn, String price, String remark) {
        try {
            int result = service.pricing(orderType, orderSn, price, remark);
            if (result > 0) {
                return Result.ok("调价成功");
            } else if (result == -1) {
                return Result.error("订单不存在或已支付");
            } else {
                return Result.error("调价失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("调价失败");
        }
    }

    /**
     * 获取异常订单列表
     *
     * @param pageNo   分页当前页
     * @param pageSize 分页 页面大小
     * @param orderSn  订单编号
     * @param status   订单状态
     * @param date     开始时间
     * @param enddate  结束时间
     */
    @RequestMapping("/listExceptionOrder")
    public Result<?> listExceptionOrder(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                        @RequestParam(name = "pageSize", defaultValue = "10") int pageSize,
                                        String orderSn, String status, String date, String enddate) {
        Page<MlccErrorOrder> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MlccErrorOrder> orderIPage = service.listExceptionOrder(page, orderSn, status, date, enddate);
            return Result.ok(orderIPage);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 订单状态跟踪(后台)
     *
     * @param orderSn   订单编号
     * @param orderType 订单leixing
     */
    @RequestMapping("/getFabricOrderTracking")
    public JSONObject getFabricOrderTracking(String orderSn, Integer orderType) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackingOrder> tracking = service.getFabricOrderTracking(orderSn, orderType);
            jsonObject.put("code", 0);
            jsonObject.put("msg", "查询成功");
            jsonObject.put("data", tracking);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 订单售后记录跟踪（总后台）
     *
     * @param token     令牌
     * @param orderSn   订单编号
     * @param orderType 订单类型
     * @return 售后记录列表
     */
    @RequestMapping("/listTeamAfter")
    public JSONObject listTeamAfter(@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                    @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, String token, String orderSn, Integer orderType) {
        Page<MlccAfterSalesinfo> page = new Page<>(pageNo, pageSize);
        JSONObject jsonObject = new JSONObject();
        try {
            IPage<MlccAfterSalesinfo> iPage = service.listTeamAfter(page, token, orderSn, orderType);
            jsonObject.put("code", 0);
            jsonObject.put("data", iPage);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 个订取产品状态跟踪列表（后台）
     *
     * @param orderSn 订单编号
     */
    @RequestMapping("/listtrackingProduct")
    public JSONObject listtrackingProduct(String orderSn) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackingProduct> list = service.listtrackingProduct(orderSn);
            jsonObject.put("code", 0);
            jsonObject.put("data", list);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 后台订单驳回
     *
     * @param orderType 订单类型
     * @param orderID   订单ID
     */
    @RequestMapping("/rejectedOrder")
    public JSONObject rejectedOrder(Integer orderType, String orderID, String remark) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.rejectedOrder(orderType, orderID, remark);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "驳回成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "驳回失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 立即发货
     *
     * @param orderSn   订单编号
     * @param yunNumber 运单号
     * @param orderType 订单类型 3:面料订单，0个订，1团订
     * @param productid 产品id（多个）
     */
    @RequestMapping("/fahuoNow")
    public JSONObject fahuoNow(String orderSn, String yunNumber, Integer orderType, String kuaidiid, String remark, String[] productid) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.fahuoNow(orderSn, yunNumber, orderType, kuaidiid, remark, productid);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "发货成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "发货失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发货失败");
        }
        return jsonObject;
    }

    /**
     * 完成订单
     *
     * @param orderSn   订单编号
     * @param orderType 订单类型 3:面料订单，0个订，1团订
     */
    @RequestMapping("/finishOrder")
    public JSONObject finishOrder(String orderSn, Integer orderType) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.finishOrder(orderSn, orderType);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 订单备库
     *
     * @param orderSn   订单编号
     * @param orderType 订单类型
     * @param remark    备注信息
     */
    @RequestMapping("/beikuOrder")
    public JSONObject beikuOrder(String orderSn, Integer orderType, String remark) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.beikuOrder(orderSn, orderType, remark);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 团订订单批次列表
     *
     * @param orderSn 订单编号
     */
    @RequestMapping("/listPacking")
    public JSONObject listPacking(String orderSn) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<TeamPackingEntity> list = service.listPacking(orderSn);
            jsonObject.put("code", 0);
            jsonObject.put("data", list);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 批次的立即发货
     *
     * @param packingID 批次ID
     * @param thirdSn   运单号
     * @param kdid      快递id
     * @param remark    发货的备注
     */
    @RequestMapping("/pixifahuoNow")
    public JSONObject pixifahuoNow(String packingID, String thirdSn, String kdid, String remark) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.pixifahuoNow(packingID, thirdSn, kdid, remark);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "发货成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "发货失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 删除批次
     *
     * @param packingID 批次ID
     */
    @RequestMapping("/delPacking")
    public JSONObject delPacking(String packingID) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.delPacking(packingID);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "删除成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "删除失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 获取批次基本信息（详情）
     *
     * @param packingID 批次ID
     */
    @RequestMapping("/basePackingDetail")
    public JSONObject basePackingDetail(String packingID) {
        JSONObject jsonObject = new JSONObject();
        try {
            TeamPackingEntity trackingTeamDepart = service.basePackingDetail(packingID);
            jsonObject.put("code", 0);
            jsonObject.put("data", trackingTeamDepart);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 获取批次下的装箱单列表和装箱单下的人员列表
     *
     * @param packingID 批次ID
     */
    @RequestMapping("/listPackage")
    public JSONObject listPackage(String packingID) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccBatchPackingInfo> infos = service.listPackage(packingID);
            jsonObject.put("code", 0);
            jsonObject.put("data", infos);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 导出装箱单人员列表
     *
     * @param id 装箱单id
     */
    @RequestMapping("/getboxPersonFile")
    public ModelAndView getboxPersonFile(String id) {
        ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
        //导出文件名称
        mv.addObject(NormalExcelConstants.FILE_NAME, "装箱单人员列表");
        //注解对象Class
        mv.addObject(NormalExcelConstants.CLASS, BoxPersonEntity.class);
        //自定义表格参数
        mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("装箱单人员列表", "装箱单人员列表"));
        //导出数据列表
        mv.addObject(NormalExcelConstants.DATA_LIST, service.getboxPersonFile(id));
        return mv;
    }

    /**
     * 获取装箱单下的人员列表
     *
     * @param id 装箱单id
     */
    @RequestMapping("/listBoxPerson")
    public JSONObject listBoxPerson(String id) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<BoxPersonEntity> personEntities = service.listBoxPerson(id);
            jsonObject.put("code", 0);
            jsonObject.put("data", personEntities);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 删除装箱单下的产品（删除关系表）
     *
     * @param id 装箱单产品关联表ID
     */
    @RequestMapping("/delBoxPro")
    public JSONObject delBoxPro(String id) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.delBoxPro(id);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "删除成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "删除失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 新增批次
     *
     * @param departID    部门ID
     * @param packingName 批次名称
     * @param orderSn     订单编号
     */
    @RequestMapping("/savePacking")
    public JSONObject savePacking(String departID, String packingName, String orderSn) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.savePacking(departID, packingName, orderSn);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "添加成功");
            } else if (result == -2) {
                jsonObject.put("code", -2);
                jsonObject.put("msg", "批次名称重复");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "添加失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 团订未发货人员名单
     *
     * @param pageNo    当前页
     * @param pageSize  页面大小
     * @param orderSn   订单编号
     * @param productID 产品ID（查询条件）
     */
    @RequestMapping("/listNotshipments")
    public Result<?> listNotshipments(@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                      @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, String orderSn, String productID) {
        try {
            Page<MyNotshipmentsEmp> page = new Page<>(pageNo, pageSize);
            IPage<MyNotshipmentsEmp> list = service.listNotshipments(page, orderSn, productID);
            return Result.ok(list);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 团订新增装箱单界面，根据批次ID查询产品列表
     *
     * @param batchID 批次ID
     */
    @RequestMapping("/getProductByBatchID")
    public JSONObject getProductByBatchID(String batchID) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccProductInfo> product = service.getProductByBatchID(batchID);
            jsonObject.put("code", 0);
            jsonObject.put("data", product);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 团订新增装箱单，并往装箱单产品关联表添加记录
     *
     * @param batchID     批次ID
     * @param packingName 装箱单名称
     * @param remark      备注
     * @param productID   选中的小产品ID列表
     */
    @RequestMapping("/saveBox")
    public JSONObject saveBox(String batchID, String packingName, String remark, String[] productID) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.saveBox(batchID, packingName, remark, productID);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "保存成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "保存失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 根据装箱单ID获取基本信息
     *
     * @param packageID 装箱单ID
     */
    @RequestMapping("/getBasePackageDEtail")
    public JSONObject getBasePackageDEtail(String packageID) {
        JSONObject jsonObject = new JSONObject();
        try {
            MlccBatchPackingInfo batchPackingInfo = service.getBasePackageDEtail(packageID);
            jsonObject.put("code", 0);
            jsonObject.put("data", batchPackingInfo);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 仅仅往装箱单下添加人员
     *
     * @param packageID 装箱单ID
     * @param productID 产品人员ID数组
     */
    @RequestMapping("/addPersononPackage")
    public JSONObject addPersononPackage(String packageID, String[] productID) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.addPersononPackage(packageID, productID);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "保存成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "保存失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 查询本次售后的小产品
     *
     * @param pageNo    当前页
     * @param pageSize  页面大小
     * @param afterCode 售后订单编号
     */
    @RequestMapping("/getAftersmallProduct")
    public Result<?> getAftersmallProduct(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                          @RequestParam(name = "pageSize", defaultValue = "10") int pageSize, String afterCode) {
        Page<MyAfterProduct> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MyAfterProduct> product = service.getAftersmallProduct(page, afterCode);
            return Result.ok(product);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 售后产品人员列表同意或拒绝
     *
     * @param afterOrderID 售后订单表ID
     * @param afterCode    售后订单编号
     * @param isAgree      是否同意 0 拒接，1同意
     * @param smallProIDS  选中的兄产品id数组
     */
    @RequestMapping("/agreeAfter")
    public JSONObject agreeAfter(String afterOrderID, String remark, String afterCode, Integer isAgree, String[] smallProIDS) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.agreeAfter(afterOrderID, remark, afterCode, isAgree, smallProIDS);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 团订售后详情查询以及拒绝的人员
     *
     * @param afterOrderID 售后订单ID
     */
    @RequestMapping("/listRefustProduct")
    public JSONObject listRefustProduct(String afterOrderID) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackAfterOrder> orderList = service.listRefustProduct(afterOrderID);
            jsonObject.put("code", 0);
            jsonObject.put("data", orderList);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 团订售后已同意的小产品
     *
     * @param afterOrderID 售后订单ID
     */
    @RequestMapping("/listAgreeProduct")
    public JSONObject listAgreeProduct(String afterOrderID) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackAfterOrder> orderList = service.listAgreeProduct(afterOrderID);
            jsonObject.put("code", 0);
            jsonObject.put("data", orderList);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 团订售后详情下的平台收货下数据（个订也可以用）
     *
     * @param afterOrderID 售后订单ID
     */
    @RequestMapping("/receiving")
    public JSONObject receiving(String afterOrderID) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackAfterOrder> result = service.receiving(afterOrderID);
            jsonObject.put("code", 0);
            jsonObject.put("data", result);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 团订售后订单详情平台发货的【确认收货】 或 【提交】
     *
     * @param afterOrderID 售后订单表ID
     * @param trackAfterID 操作的售后订单跟踪表ID
     * @param type         0 提交，1 确认收货
     */
    @RequestMapping("/receiptsOrSubmit")
    public JSONObject receiptsOrSubmit(String afterCode, String afterOrderID, String trackAfterID, Integer type, String remark) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.receiptsOrSubmit(afterCode, afterOrderID, trackAfterID, type, remark);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("data", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("data", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("data", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 个订售后订单详情平台发货的【确认收货】 或 【提交】
     *
     * @param afterCode    售后订单编码
     * @param afterOrderID 售后订单表ID
     * @param trackAfterID 操作的售后订单跟踪表ID
     * @param type         0 提交，1 确认收货
     * @param remark       备注
     */
    @RequestMapping("/receiptsOrSubmitSingle")
    public JSONObject receiptsOrSubmitSingle(String afterCode, String afterOrderID, String trackAfterID, Integer type, String remark) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.receiptsOrSubmitSingle(afterCode, afterOrderID, trackAfterID, type, remark);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("data", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("data", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("data", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 产品已收列表
     *
     * @param afterCode 售后订单编号
     */
    @RequestMapping("/listProductget")
    public JSONObject listProductget(String afterCode) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MyAfterProduct> productList = service.listProductget(afterCode);
            jsonObject.put("code", 0);
            jsonObject.put("data", productList);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 更新产品状态
     *
     * @param id 售后产品ID
     */
    @RequestMapping("/updateAfterPro")
    public JSONObject updateAfterPro(String id, Integer status) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.updateAfterPro(id, status);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("data", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("data", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("data", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 根据批次名称查询批次基本信息
     *
     * @param orderSn   团订订单编号
     * @param batchName 批次名称
     */
    @RequestMapping("/getBatchByCode")
    public JSONObject getBatchByCode(String orderSn, String batchName) {
        JSONObject jsonObject = new JSONObject();
        try {
            MlccTrackingTeamDepart batch = service.getBatchByCode(orderSn, batchName);
            jsonObject.put("code", 0);
            jsonObject.put("data", batch);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 把已入库的产品添加到装箱单
     *
     * @param batchID    批次ID
     * @param packageID  装箱单ID
     * @param productIDS 选中的产品id数组
     */
    @RequestMapping("/addProductonBox")
    public JSONObject addProductonBox(String batchID, String packageID, String[] productIDS) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.addProductonBox(batchID, packageID, productIDS);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("data", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("data", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("data", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 批次装箱的保存功能（在添加产品之后）
     *
     * @param adterCode    售后订单编号
     * @param remark       备注
     * @param afterOrderId 售后订单ID
     * @param packageid    装箱单id
     */
    @RequestMapping("/saveProInPPackage")
    public JSONObject saveProInPPackage(String adterCode, String remark, String afterOrderId, String packageid) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.saveProInPPackage(adterCode, remark, afterOrderId, packageid);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("data", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("data", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("data", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 前端展示售后产品发货列表
     *
     * @param afterCode 售后订单编号
     */
    @RequestMapping("/outAfterPro")
    public JSONObject outAfterPro(String afterCode) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MyAfterProduct> products = service.outAfterPro(afterCode);
            jsonObject.put("code", 0);
            jsonObject.put("data", products);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 售后尺寸列表
     *
     * @param smallProid 售后小产品ID
     * @param afterCode  售后订单编号
     * @param isafter    1返修，2重做
     */
    @RequestMapping("/listAfterSize")
    public JSONObject listAfterSize(String smallProid, String afterCode, Integer isafter) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MyBodySizeInfo> sizeInfos = service.listAfterSize(smallProid, afterCode, isafter);
            jsonObject.put("code", 0);
            jsonObject.put("data", sizeInfos);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 面料售后的同意或拒绝
     *
     * @param afterID 售后订单ID
     * @param remark  备注
     * @param isAgree 1拒绝，2通过审核
     */
    @RequestMapping("/fabricOrderAfterIsAagree")
    public JSONObject fabricOrderAfterIsAagree(String afterID, String remark, Integer isAgree) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.fabricOrderAfterIsAagree(afterID, remark, isAgree);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "操作失败");
        }
        return jsonObject;
    }

    /**
     * 面料、个订 订单售后已拒绝
     *
     * @param afterID 售后订单ID
     */
    @RequestMapping("/fabricAfterOrderRefuse")
    public JSONObject fabricAfterOrderRefuse(String afterID) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackAfterOrder> afterOrders = service.fabricAfterOrderRefuse(afterID);
            jsonObject.put("code", 0);
            jsonObject.put("data", afterOrders);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 面料、个订 订单售后已接受
     *
     * @param afterID 售后订单ID
     */
    @RequestMapping("/fabricAfterOrderAgree")
    public JSONObject fabricAfterOrderAgree(String afterID) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackAfterOrder> afterOrders = service.fabricAfterOrderAgree(afterID);
            jsonObject.put("code", 0);
            jsonObject.put("data", afterOrders);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 个订 订单售后后台发货
     *
     * @param afterID 售后订单ID
     */
    @RequestMapping("/isFahuo")
    public JSONObject isFahuo(String afterID) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackAfterOrder> afterOrders = service.isFahuo(afterID);
            jsonObject.put("code", 0);
            jsonObject.put("data", afterOrders);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 个订售后详情获取产品返修尺寸数据
     *
     * @param orderSn   个订订单编号
     * @param afterCode 售后订单编号
     */
    @RequestMapping("/listSingleAfterProductSize")
    public JSONObject listSingleAfterProductSize(String orderSn, String afterCode) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<Myproduct> myproducts = service.listSingleAfterProductSize(orderSn, afterCode);
            jsonObject.put("code", 0);
            jsonObject.put("data", myproducts);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 个订售后的同意或者拒绝
     *
     * @param afterID  售后订单ID
     * @param remark   填写的备注
     * @param isAgree  是否同意 1拒绝，2通过审核
     * @param saddress 收货地址
     * @param sperson  收货人
     * @param sphone   收货电话
     */
    @RequestMapping("/singlrAfterOrderIsAgree")
    public JSONObject singlrAfterOrderIsAgree(String afterID, String remark, Integer isAgree, String saddress, String sperson, String sphone) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.singlrAfterOrderIsAgree(afterID, remark, isAgree, saddress, sperson, sphone);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "操作失败");
        }
        return jsonObject;
    }

    /**
     * 个订售后，产品已收列表
     *
     * @param afterID 售后订单ID
     */
    @RequestMapping("/SingleProGet")
    public JSONObject SingleProGet(String afterID) {
        JSONObject jsonObject = new JSONObject();
        try {
            MlccAfterSalesinfo mlccTrackAfterOrders = service.SingleProGet(afterID);
            jsonObject.put("code", 0);
            jsonObject.put("data", mlccTrackAfterOrders);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "发生异常");
        }
        return jsonObject;
    }

    /**
     * 个订售后更新产品状态
     *
     * @param afterTrackID 售后订单跟踪记录ID
     * @param status       产品状态
     */
    @RequestMapping("/updateSingleAfterOrder")
    public JSONObject updateSingleAfterOrder(String afterTrackID, String status) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.updateSingleAfterOrder(afterTrackID, status);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "操作失败");
        }
        return jsonObject;
    }

    /**
     * 个订售后售后订单发货
     *
     * @param afterID 售后订单id
     * @param remark  备注
     * @param kdid    快递id
     * @param number  运单号
     */
    @RequestMapping("/singleAfterProductOut")
    public JSONObject sproductFahuo(String afterID, String remark, String kdid, String number) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.sproductFahuo(afterID, remark, kdid, number);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "操作失败");
        }
        return jsonObject;
    }

    /**
     * 个订产品状态跟踪更新产品状态
     *
     * @param productID 产品ID
     * @param orderSn   个订订单编号
     */
    @RequestMapping("/updateProductStatus")
    public JSONObject updateProductStatus(String productID, String orderSn, Integer status, String name, String remark, String wrater) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.updateProductStatus(productID, orderSn, status, name, remark, wrater);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "操作失败");
        }
        return jsonObject;
    }

    /**
     * 面料售后订单详情平台发货的【确认收货】 或 【提交】
     *
     * @param afterCode    售后订单编码
     * @param afterOrderID 售后订单表ID
     * @param trackAfterID 操作的售后订单跟踪表ID
     * @param type         0 提交，1 确认收货
     * @param remarks      备注
     */
    @RequestMapping("/fabricAafterupdate")
    public JSONObject fabricAafterupdate(String afterCode, String afterOrderID, String trackAfterID, Integer type, String remarks) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.fabricAafterupdate(afterCode, afterOrderID, trackAfterID, type, remarks);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("data", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("data", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("data", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 面料售后的产品已收
     *
     * @param afterOrderID 售后订单ID
     */
    @RequestMapping("/fabricAafteryishou")
    public JSONObject fabricAafteryishou(String afterOrderID) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackAfterOrder> afterOrders = service.fabricAafteryishou(afterOrderID);
            jsonObject.put("code", 0);
            jsonObject.put("data", afterOrders);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "操作失败");
        }
        return jsonObject;
    }

    /**
     * 换货的面料售后订单  发货
     *
     * @param afterOrderID 售后订单ID
     * @param number       运单号
     * @param trackid      需要发货的售后订单跟踪id
     * @param kdid         快递id
     * @param remake       备注
     */
    @RequestMapping("/fabricAfterFahuo")
    public JSONObject fabricAfterFahuo(String afterOrderID, String number, String trackid, String kdid, String remake) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.fabricAfterFahuo(afterOrderID, number, trackid, kdid, remake);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("data", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("data", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("data", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 个订订单成本 面料成本
     *
     * @param orderSn 个订订单成本
     */
    @RequestMapping("/SingleChengbenFabric")
    public JSONObject SingleChengbenFabric(String orderSn) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccFabricInfo> list = service.SingleChengbenFabric(orderSn);
            jsonObject.put("code", 0);
            jsonObject.put("data", list);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "操作失败");
        }
        return jsonObject;
    }

    /**
     * 团订订单的面料成本
     *
     * @param orderSn 团订订单编号
     */
    @RequestMapping("/teamFabricCB")
    public JSONObject teamFabricCB(String orderSn) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccFabricInfo> list = service.teamFabricCB(orderSn);
            jsonObject.put("code", 0);
            jsonObject.put("data", list);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "操作失败");
        }
        return jsonObject;
    }

    /**
     * 获取订单下的加价成本 (个订与团订通用)
     *
     * @param pageNo   当前页
     * @param pageSize 页面大小
     * @param orderSn  订单编号
     */
    @RequestMapping("/getJiajiaCB")
    public Result<?> getJiajiaCB(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                 @RequestParam(name = "pageSize", defaultValue = "10") int pageSize, String orderSn) {
        Page<MlccPaidanOrderCost> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MlccPaidanOrderCost> jiajiaCB = service.getJiajiaCB(page, orderSn);
            return Result.ok(jiajiaCB);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 获取订单下的工艺成本 (个订与团订通用)
     *
     * @param pageNo   当前页
     * @param pageSize 页面大小
     * @param orderSn  订单编号
     */
    @RequestMapping("/getGYCB")
    public Result<?> getGYCB(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                             @RequestParam(name = "pageSize", defaultValue = "10") int pageSize, String orderSn) {
        Page<MlccPaidanOrderGongyi> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MlccPaidanOrderGongyi> jiajiaCB = service.getGYCB(page, orderSn);
            return Result.ok(jiajiaCB);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 获取订单下的返修成本 (个订与团订通用)
     *
     * @param pageNo   当前页
     * @param pageSize 页面大小
     * @param orderSn  订单编号
     */
    @RequestMapping("/getFanxiuCB")
    public Result<?> getFanxiuCB(@RequestParam(name = "pageNo", defaultValue = "1") int pageNo,
                                 @RequestParam(name = "pageSize", defaultValue = "10") int pageSize, String orderSn) {
        Page<MlccPaidanOrderAfter> page = new Page<>(pageNo, pageSize);
        try {
            IPage<MlccPaidanOrderAfter> fanxiuCB = service.getFanxiuCB(page, orderSn);
            return Result.ok(fanxiuCB);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 获取快递信息
     */
    @RequestMapping("/getKuaidi")
    public JSONObject getKuaidi() {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccCourierInfo> serviceKuaidi = service.getKuaidi();
            jsonObject.put("code", 0);
            jsonObject.put("data", serviceKuaidi);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 产品选择供应商
     *
     * @param proid 产品id
     * @param gysid 供应商id
     */
    @RequestMapping("/selectGYS")
    public JSONObject selectGYS(String proid, String gysid) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.selectGYS(proid, gysid);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 面料售后详情——后台发货的数据
     *
     * @param id 售后订单id
     */
    @RequestMapping("/fabricAdminFahuo")
    public JSONObject fabricAdminFahuo(String id) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackAfterOrder> afterOrders = service.fabricAdminFahuo(id);
            jsonObject.put("code", 0);
            jsonObject.put("data", afterOrders);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 面料售后详情——退款记录
     *
     * @param id 售后订单id
     */
    @RequestMapping("/fabrictuikuan")
    public JSONObject fabrictuikuan(String id) {
        JSONObject jsonObject = new JSONObject();
        try {
            List<MlccTrackAfterOrder> afterOrders = service.fabrictuikuan(id);
            jsonObject.put("code", 0);
            jsonObject.put("data", afterOrders);
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "查询失败");
        }
        return jsonObject;
    }

    /**
     * 完成订单
     *
     * @param orderSn 订单编号
     * @param type    0面；1个，2团
     */
    @RequestMapping("/orderOk")
    public JSONObject orderOk(String orderSn, Integer type) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.orderOk(orderSn, type);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "接单成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "该订单不存在或已结单");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 完成售后订单
     *
     * @param id 售后订单id
     */
    @RequestMapping("/afterOK")
    public JSONObject afterOK(String id) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.afterOK(id);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 更新面料的售后价格
     *
     * @param price   价格
     * @param afterid 售后订单id
     */
    @RequestMapping("/updateFabricAfterPrice")
    public JSONObject updateFabricAfterPrice(String afterid, String price) {
        JSONObject jsonObject = new JSONObject();
        try {
            int result = service.updateFabricAfterPrice(afterid, price);
            if (result > 0) {
                jsonObject.put("code", 0);
                jsonObject.put("msg", "操作成功");
            } else {
                jsonObject.put("code", 1);
                jsonObject.put("msg", "操作失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            jsonObject.put("code", 1);
            jsonObject.put("msg", "系统异常");
        }
        return jsonObject;
    }

    /**
     * 团体订单编辑批次删除装箱单
     *
     * @param boxid 装箱单id
     */
    @RequestMapping("/deleteBox")
    public Result<?> deleteBox(String boxid) {
        try {
            int i = service.deleteBox(boxid);
            if (i > 0) {
                return Result.ok("删除成功");
            } else {
                return Result.error("删除失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("删除失败");
        }
    }

    /**
     * 团订获取重做的面料列表
     *
     * @param afterCode 售后订单编号
     */
    @RequestMapping("/tramAfterFabriclIst")
    public Result<?> tramAfterFabriclIst(String afterCode) {
        try {
            List<MlccFabricInfo> infos = service.tramAfterFabriclIst(afterCode);
            return Result.ok(infos);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }

    /**
     * 小产品详情
     *
     * @param id 小产品id
     */
    @RequestMapping("/smallProDetail")
    public Result<?> smallProDetail(String id) {
        try {
            MlccCustomerProductInfo detail = service.smallProDetail(id);
            return Result.ok(detail);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("查询失败");
        }
    }
}
